import java.util.Scanner;

/**
 * Description:
 * Date: 2025-09-24
 * Time: 17:45
 */
public class Test {

    //运算符学习
    public static void main1(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > b);//这是一个布尔表达式 返回的结果只有 true false

        //这样是无法进行计算的  java是先计算 3 < a 得true， 你需要拿true与12进行比较，两种类型不兼容，报错
//        System.out.println(3 < a <12);
    }


    public static void main2(String[] args) {
        //逻辑与 && : 有假则假 全真为真
        int a = 1;
        int b = 2;
        System.out.println(a < b && a == 1);//真 真 --> 真
        System.out.println(a < b && a == 2);//真 假 --> 假
        System.out.println(a > b && b == 2);//假 真 --> 假
        System.out.println(a > b && b == 1);//假 假 --> 假

    }

    public static void main3(String[] args) {
        //逻辑或 || : 有真则真 全假为假
        int a = 1;
        int b = 2;
        System.out.println(a < b || a == 1);//真 真 --> 真
        System.out.println(a < b || a == 2);//真 假 --> 真
        System.out.println(a > b || b == 2);//假 真 --> 真
        System.out.println(a > b || b == 1);//假 假 --> 假
    }

    public static void main4(String[] args) {
        //逻辑非 ！ : 真变假  假变真
        int a = 1;
        int b = 2;
        System.out.println(!(a > b));//假 --> 真
        System.out.println(!(a < b));//真 --> 假
    }

    public static void main5(String[] args) {
        //&& 与 || 的运算会遵循短路求值的规则

        //表达式10/0 == 1存在明显的错误，除数不能为0  但 && 的判定规则是有假则假
        // 它先对10>20 进行判断，判断为假，则已经确定了整个表达式都为假，它就不会对第二个表达式进行判定
        System.out.println(10 > 20 && 10/0 == 1);//false
        //判断第一个表达式 10 < 20 为true，则整个表达式都为true，不对第二个表达式进行判断
        System.out.println(10 < 20 || 10/0 == 1);//true

    }

    public static void main6(String[] args) {
        //按位与 & : 在二进制位上进行计算 规则：有0则0，全1为1
        int a = 9;
        int b = 37;
        System.out.println(a & b);
        //以8为比特位为例
        //9的二进制值： 0000 1001
        //37的二进制值：0010 0101
        //         ： 0000 0001 (有0则0，全1为1) 故最终结果是1
    }

    public static void main7(String[] args) {
        //按位或 | : 在二进制位上进行计算 规则：有1则1，全0为0
        int a = 9;
        int b = 37;
        System.out.println(a | b);
        //以8为比特位为例
        //9的二进制值： 0000 1001
        //37的二进制值：0010 0101
        //         ： 0010 1101 (有1则1，全0为0) 故最终结果是45
    }

    public static void main8(String[] args) {
        //按位异或 ^ : 在二进制位上进行计算 规则：相同为0，不同为1
        //任何数异或0都等于它本身
        int a = 9;
        int b = 37;
        System.out.println(a ^ b);
        //以8为比特位为例 （java中对二进制位的操作是在补码上操作）
        //9的二进制值： 0000 1001
        //37的二进制值：0010 0101
        //         ： 0010 1100 (相同为0，不同为1) 故最终结果是44
    }

    public static void main9(String[] args) {
        //算术左移 << : 从二进制位最左侧位丢弃，在最右侧补0
        //一般认为对n进行算术左移x位，则是对n进行：n * 2^x
        int a = -5;
        System.out.println(a << 1);
        //对-5进行算术左移1位，以8位二进制为例
        //-5的补码二进制值；1111 1011
        //最左侧丢弃一位，最右侧补0： 111 10110 --> 原码：1000 1010 此为-10的原码
    }

    public static void main10(String[] args) {
        //算术右移 >> : 从二进制位丢弃最右侧位，在最左侧补符号位
        //一般认为对n进行算术右移x位，则是对n：n / 2^x (相下取整)
        int a = -5;
        System.out.println(a >> 1);
        //对-5进行算术右移1位，以8位二进制为例
        //-5的补码二进制值；1111 1011
        //最右侧丢弃一位，最左侧补符号位：11111 101 --> 原码 1000 0011 此为-3的补码
    }

    public static void main11(String[] args) {
        //无符号右移 >>> : 从二进制位丢弃最右侧位，在最左侧补0
        int a = -1;
        System.out.println(a >>> 1);
        //对-1进行无符号右移1位，以8位二进制为例
        //-1的补码：1111 1111
        //丢弃最右侧位，在最左侧补0 ： 01111 111 --> 此时-1经过无符号右移后变成了正数 2^31-1
    }

    public static void main12(String[] args) {
        //三目运算符 / 条件运算符
        //布尔表达式1?:表达式2:表达式3  若布尔表达式1为真，则返回表达式2的结果，否则返回表达式3结果
        int a = 10 > 5? 10: 3;
        System.out.println(a);
    }



    //逻辑控制
    public static void main13(String[] args) {
//        选择语句 : 条件表达式 必须是 布尔表达式
//        语法格式1
//        if((条件)布尔表达式){ 如果布尔表达式为true，则执行语句1
//         语句1;
//         }
        int a = 99;
        if(a > 80){
            System.out.println("1111");
        }

//        语法格式2：如果布尔表达式的结果为true，则执行语句1，否则执行语句2
//        if(布尔表达式){
//        语句1;
//        }else{
//        语句2;
//        }
        int b = 10;
        int c = 20;
        if (b > c){
            System.out.println("101010");
        }else {
            System.out.println("202020");
        }

//        语法格式3：若表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则表达式3成立，执行语句3
//        if(布尔表达式1){
//        语句1;
//        }else if (布尔表达式2){
//        语句2;
//        }else {  （else if 语句可多重嵌套，语法格式不变）
//        语句3;
//        }
        int d = 10;
        if(d > 10){
            System.out.println("d>10");
        }else if (d < 10){
            System.out.println("d<10");
        }else{
            System.out.println("d==10");
        }

    }

    public static void main14(String[] args) {
        //悬垂else问题
        int a = 10;
        if(a > 0){
            if(a > 5){
                System.out.println("a > 5");
            }else // 这个else是与最近的if语句匹配的，不是与哪个if在都一条竖线上就跟谁，是上下搭配
                System.out.println("a < 5 && a > 0");
        }
    }

    public static void main15(String[] args) {
        //switch 选择语句
        int a = 3;
//        switch(表达式){
//        case 常量值:{
//         语句;
//        [break;] 这里起结束作用，若无break则会一直执行下去，直到遇到下一个break或执行完default
//         }
//         }
//
//        case后的常量值不可重复
//
//        float double long boolean 这四种类型不能作为switch的参数
        float f = 12.4f;
        switch(a){
            case 1:{
                System.out.println(1);
                //break;
            }
            case 2:{
                System.out.println(2);
                break;
            }
            case 3:{
                System.out.println(3);
                break;
            }
            default:
                System.out.println("error!");
        }
    }

    public static void main16(String[] args) {
//        while 循环
//        语法：while(循环条件){  若 循环条件为true，则执行循环语句，直到循环条件为false
//             循环语句;
//         }

        //计算1-100的和
        int i = 1;
        int sum = 0;
        while(i <= 100){
            sum += i;
            i++;//注意循环条件的变化，否则可能会导致循环条件一直为真，程序执行死循环
        }
        System.out.println(sum);

        //计算5的阶乘
        int n = 1;
        int ret = 1;
        while(n <= 5){
            ret *= n;
            n++;
        }
        System.out.println(ret);

        //计算1-5的阶乘的和
        int a = 1;
        int sum1 = 0;
        while(a <= 5){
            int b = 1;
            int re = 1;
            while(b <= a){
                re *= b;
                b++;
            }
            a++;
            sum1 += re;
        }
        System.out.println(sum1);
    }

    public static void main17(String[] args) {
        // break: 让循环提前结束
        //如，找出100-200内第一个3的倍数，我只需找出第一个3的倍数就可以结束循环了，剩下的操作就不需要执行了，使用break
        int i = 100;
        while (i <= 200){
            if(i % 3 == 0){
                System.out.println(i);
                break;//此时找到第一个3的倍数，执行break，结束循环
            }
            i++;
        }
    }

    public static void main18(String[] args) {
        //contiune : 在执行某次循环中，跳过本次循环，执行下一个循环
        //如，找出100-200内所有3的倍数
        int i = 100;
        while(i < 200){
            if(i % 3 != 0){  //不是3的倍数执行if语句
                i++;//continue语句前一般都需要进行循环条件的改变
                continue;//当执行到contiune时，程序会直接跳过下面的语句，会到循环条件的判定部分。忽略掉打印3的倍数的语句
            }
            System.out.println(i);
            i++;
        }
    }

    public static void main19(String[] args) {
//        for循环 语法
//         for(表达式1;布尔表达式2;表达式3){
//          循环体;
//         }
//        表达式1:    循环条件的初始值设置，在循环最开始时执行，只执行一次
//        布尔表达式2:循环时设定的循环条件，。满足则继续循环，不满足则循环结束
//        表达式3:   循环条件的更新方式
//
//        如，打印1-10
//        int i = 1; 确定循环条件变量的初始值
//        i <= 10;   循环条件，判断循环知否继续进行
//        i++  循环条件的变化
        int sum = 0;
        for(int i = 1; i <= 10; i++){
            System.out.println(i);
        }
    }

    public static void main20(String[] args) {
        //从键盘上获取输入
        Scanner scanner = new Scanner(System.in);//相当于准备工作，必需要的
        //调用scanner这个类对象所包含的类方法
        int a = scanner.nextInt();//nextInt() 这个方法用来读取一个整数
        System.out.println(a);

        //这里的读取有一个易错点：当你在键盘上点回车确认读取该整数时，这个回车键会被衔接的读取字符串的代码误认为时字符
        //                             所以str会读取空白，

        scanner.nextLine();//在读取字符串之前将回车键读取掉，不影响字符串的读取

        // nextLine() 与 next()方法的区别：nextLine()是读取一行字符串，包括空格
        //                              next()是读取一个字符串，遇到空格会结束
        String str = scanner.nextLine();
        System.out.println(str);
    }

    public static void main(String[] args) {
        //计算1-n的阶乘之和
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            int ret = 1;
            for (int j = 1; j <= i; j++) {
                ret *= j;
            }
            sum += ret;
        }
        System.out.println(sum);
    }






}
